// Generated from D:/BASIC/src/BasicParser.g4 by ANTLR 4.13.1
 package cn.stevenyang.gen; 
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class BasicParserParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, DIM=6, AS=7, ADD=8, MINUS=9, MULTIPLY=10, 
		DIVIDE=11, MOD=12, LPARENTHESES=13, RPARENTHESES=14, BITAND=15, BITOR=16, 
		AND=17, OR=18, XOR=19, NOT=20, CONCATENATE=21, EQ=22, NEQ=23, GT=24, LT=25, 
		GTE=26, LTE=27, ASSIGN=28, COMMENT=29, IF=30, ELSEIF=31, ELSE=32, ENDIF=33, 
		THEN=34, FOR=35, TO=36, DOWNTO=37, NEXT=38, STEP=39, WHILE=40, ENDWHILE=41, 
		DO=42, LOOP=43, BREAK=44, CONTINUE=45, SUB=46, ENDSUB=47, FUNCTION=48, 
		ENDFUNCTION=49, RETURN=50, EXITSUB=51, TRUE=52, FALSE=53, NEW=54, DOT=55, 
		CLASS=56, INHERITS=57, IMPLEMENTS=58, INTERFACE=59, SHARED=60, ENDCLASS=61, 
		ENDINTERFACE=62, PUBLIC=63, PROTECTED=64, PRIVATE=65, ME=66, FOREACH=67, 
		OF=68, ENDFOREACH=69, ARRAY_SYMBOL=70, STRING=71, ID=72, INT=73, DECIMAL=74, 
		NEWLINE=75, MAP_ASSIGN=76, WS=77;
	public static final int
		RULE_numeric = 0, RULE_assignment = 1, RULE_defparam = 2, RULE_process = 3, 
		RULE_expression = 4, RULE_funccallparams = 5, RULE_ifexpression = 6, RULE_elseifexpression = 7, 
		RULE_elseexpression = 8, RULE_forexpression = 9, RULE_foreachexpr = 10, 
		RULE_whileexpression = 11, RULE_doloop = 12, RULE_deffuncparam = 13, RULE_sub = 14, 
		RULE_func = 15, RULE_impllist = 16, RULE_defclass = 17, RULE_accessclass = 18, 
		RULE_classsub = 19, RULE_classfunc = 20, RULE_classvar = 21, RULE_classblock = 22, 
		RULE_classbody = 23, RULE_array = 24, RULE_map = 25, RULE_arraytype = 26, 
		RULE_astype = 27;
	private static String[] makeRuleNames() {
		return new String[] {
			"numeric", "assignment", "defparam", "process", "expression", "funccallparams", 
			"ifexpression", "elseifexpression", "elseexpression", "forexpression", 
			"foreachexpr", "whileexpression", "doloop", "deffuncparam", "sub", "func", 
			"impllist", "defclass", "accessclass", "classsub", "classfunc", "classvar", 
			"classblock", "classbody", "array", "map", "arraytype", "astype"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "','", "'['", "']'", "'{'", "'}'", "'Dim'", "'As'", "'+'", "'-'", 
			"'*'", "'/'", "'%'", "'('", "')'", "'BitAnd'", "'BitOr'", "'And'", "'Or'", 
			"'^'", "'Not'", "'&'", "'=='", "'<>'", "'>'", "'<'", "'>='", "'<='", 
			"'='", "'''", "'If'", "'ElseIf'", "'Else'", "'End If'", "'Then'", "'For'", 
			"'To'", "'DownTo'", "'Next'", "'Step'", "'While'", "'End While'", "'Do'", 
			"'Loop'", "'Break'", "'Continue'", "'Sub'", "'End Sub'", "'Function'", 
			"'End Function'", "'Return'", "'Exit Sub'", "'True'", "'False'", "'New'", 
			"'.'", "'Class'", "'Inherits'", "'Implements'", "'Interface'", "'Shared'", 
			"'End Class'", "'End Interface'", "'Public'", "'Protected'", "'Private'", 
			"'Me'", "'ForEach'", "'OF'", "'End ForEach'", "'[]'", null, null, null, 
			null, null, "':='"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, "DIM", "AS", "ADD", "MINUS", "MULTIPLY", 
			"DIVIDE", "MOD", "LPARENTHESES", "RPARENTHESES", "BITAND", "BITOR", "AND", 
			"OR", "XOR", "NOT", "CONCATENATE", "EQ", "NEQ", "GT", "LT", "GTE", "LTE", 
			"ASSIGN", "COMMENT", "IF", "ELSEIF", "ELSE", "ENDIF", "THEN", "FOR", 
			"TO", "DOWNTO", "NEXT", "STEP", "WHILE", "ENDWHILE", "DO", "LOOP", "BREAK", 
			"CONTINUE", "SUB", "ENDSUB", "FUNCTION", "ENDFUNCTION", "RETURN", "EXITSUB", 
			"TRUE", "FALSE", "NEW", "DOT", "CLASS", "INHERITS", "IMPLEMENTS", "INTERFACE", 
			"SHARED", "ENDCLASS", "ENDINTERFACE", "PUBLIC", "PROTECTED", "PRIVATE", 
			"ME", "FOREACH", "OF", "ENDFOREACH", "ARRAY_SYMBOL", "STRING", "ID", 
			"INT", "DECIMAL", "NEWLINE", "MAP_ASSIGN", "WS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "BasicParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public BasicParserParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NumericContext extends ParserRuleContext {
		public NumericContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_numeric; }
	 
		public NumericContext() { }
		public void copyFrom(NumericContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NumberContext extends NumericContext {
		public Token t;
		public TerminalNode INT() { return getToken(BasicParserParser.INT, 0); }
		public TerminalNode DECIMAL() { return getToken(BasicParserParser.DECIMAL, 0); }
		public NumberContext(NumericContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterNumber(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitNumber(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitNumber(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NumericContext numeric() throws RecognitionException {
		NumericContext _localctx = new NumericContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_numeric);
		int _la;
		try {
			_localctx = new NumberContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(56);
			((NumberContext)_localctx).t = _input.LT(1);
			_la = _input.LA(1);
			if ( !(_la==INT || _la==DECIMAL) ) {
				((NumberContext)_localctx).t = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AssignmentContext extends ParserRuleContext {
		public AssignmentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignment; }
	 
		public AssignmentContext() { }
		public void copyFrom(AssignmentContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarDefineContext extends AssignmentContext {
		public TerminalNode DIM() { return getToken(BasicParserParser.DIM, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public TerminalNode AS() { return getToken(BasicParserParser.AS, 0); }
		public AstypeContext astype() {
			return getRuleContext(AstypeContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(BasicParserParser.ASSIGN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public VarDefineContext(AssignmentContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterVarDefine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitVarDefine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitVarDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AssignmentContext assignment() throws RecognitionException {
		AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_assignment);
		try {
			_localctx = new VarDefineContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(58);
			match(DIM);
			setState(59);
			match(ID);
			setState(60);
			match(AS);
			setState(61);
			astype();
			setState(64);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				{
				setState(62);
				match(ASSIGN);
				setState(63);
				expression(0);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DefparamContext extends ParserRuleContext {
		public DefparamContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_defparam; }
	 
		public DefparamContext() { }
		public void copyFrom(DefparamContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DefParametersContext extends DefparamContext {
		public List<TerminalNode> ID() { return getTokens(BasicParserParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(BasicParserParser.ID, i);
		}
		public TerminalNode AS() { return getToken(BasicParserParser.AS, 0); }
		public TerminalNode ASSIGN() { return getToken(BasicParserParser.ASSIGN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public DefParametersContext(DefparamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterDefParameters(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitDefParameters(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitDefParameters(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DefparamContext defparam() throws RecognitionException {
		DefparamContext _localctx = new DefparamContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_defparam);
		int _la;
		try {
			_localctx = new DefParametersContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(66);
			match(ID);
			setState(67);
			match(AS);
			setState(68);
			match(ID);
			setState(71);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ASSIGN) {
				{
				setState(69);
				match(ASSIGN);
				setState(70);
				expression(0);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ProcessContext extends ParserRuleContext {
		public ProcessContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_process; }
	 
		public ProcessContext() { }
		public void copyFrom(ProcessContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class GenericExpressionContext extends ProcessContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode NEWLINE() { return getToken(BasicParserParser.NEWLINE, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public GenericExpressionContext(ProcessContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterGenericExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitGenericExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitGenericExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProcessContext process() throws RecognitionException {
		ProcessContext _localctx = new ProcessContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_process);
		try {
			_localctx = new GenericExpressionContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(73);
			expression(0);
			setState(76);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
			case 1:
				{
				setState(74);
				match(NEWLINE);
				setState(75);
				process();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionContext extends ParserRuleContext {
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
	 
		public ExpressionContext() { }
		public void copyFrom(ExpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IfExpressionExprContext extends ExpressionContext {
		public IfexpressionContext ifexpression() {
			return getRuleContext(IfexpressionContext.class,0);
		}
		public IfExpressionExprContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterIfExpressionExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitIfExpressionExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitIfExpressionExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareLtContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode LT() { return getToken(BasicParserParser.LT, 0); }
		public CompareLtContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareLt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareLt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareLt(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicOrContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode OR() { return getToken(BasicParserParser.OR, 0); }
		public LogicOrContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicOr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicOr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NumContext extends ExpressionContext {
		public NumericContext numeric() {
			return getRuleContext(NumericContext.class,0);
		}
		public NumContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterNum(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitNum(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitNum(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArthmeticModContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MOD() { return getToken(BasicParserParser.MOD, 0); }
		public ArthmeticModContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArthmeticMod(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArthmeticMod(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArthmeticMod(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ReturnStatementContext extends ExpressionContext {
		public TerminalNode RETURN() { return getToken(BasicParserParser.RETURN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ReturnStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterReturnStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitReturnStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitReturnStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class VarDefineExprContext extends ExpressionContext {
		public AssignmentContext assignment() {
			return getRuleContext(AssignmentContext.class,0);
		}
		public VarDefineExprContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterVarDefineExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitVarDefineExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitVarDefineExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareLteContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode LTE() { return getToken(BasicParserParser.LTE, 0); }
		public CompareLteContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareLte(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareLte(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareLte(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolTrueContext extends ExpressionContext {
		public TerminalNode TRUE() { return getToken(BasicParserParser.TRUE, 0); }
		public BoolTrueContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterBoolTrue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitBoolTrue(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitBoolTrue(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicAndContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode AND() { return getToken(BasicParserParser.AND, 0); }
		public LogicAndContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicAnd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicAnd(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicAnd(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ConcatenateStrStatementContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode CONCATENATE() { return getToken(BasicParserParser.CONCATENATE, 0); }
		public ConcatenateStrStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterConcatenateStrStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitConcatenateStrStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitConcatenateStrStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicBitAndContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode BITAND() { return getToken(BasicParserParser.BITAND, 0); }
		public LogicBitAndContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicBitAnd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicBitAnd(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicBitAnd(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicXorContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode XOR() { return getToken(BasicParserParser.XOR, 0); }
		public LogicXorContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicXor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicXor(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicXor(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareGteContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode GTE() { return getToken(BasicParserParser.GTE, 0); }
		public CompareGteContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareGte(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareGte(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareGte(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class GetVarExprContext extends ExpressionContext {
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public GetVarExprContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterGetVarExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitGetVarExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitGetVarExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArthmeticMinusContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MINUS() { return getToken(BasicParserParser.MINUS, 0); }
		public ArthmeticMinusContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArthmeticMinus(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArthmeticMinus(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArthmeticMinus(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareNeqContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode NEQ() { return getToken(BasicParserParser.NEQ, 0); }
		public CompareNeqContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareNeq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareNeq(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareNeq(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicNotContext extends ExpressionContext {
		public TerminalNode NOT() { return getToken(BasicParserParser.NOT, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public LogicNotContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicNot(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicNot(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicNot(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LogicBitOrContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode BITOR() { return getToken(BasicParserParser.BITOR, 0); }
		public LogicBitOrContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterLogicBitOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitLogicBitOr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitLogicBitOr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolFalseContext extends ExpressionContext {
		public TerminalNode FALSE() { return getToken(BasicParserParser.FALSE, 0); }
		public BoolFalseContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterBoolFalse(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitBoolFalse(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitBoolFalse(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ForEachExprStatementContext extends ExpressionContext {
		public ForeachexprContext foreachexpr() {
			return getRuleContext(ForeachexprContext.class,0);
		}
		public ForEachExprStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterForEachExprStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitForEachExprStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitForEachExprStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArthmeticAddContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode ADD() { return getToken(BasicParserParser.ADD, 0); }
		public ArthmeticAddContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArthmeticAdd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArthmeticAdd(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArthmeticAdd(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BreakStatementContext extends ExpressionContext {
		public TerminalNode BREAK() { return getToken(BasicParserParser.BREAK, 0); }
		public TerminalNode INT() { return getToken(BasicParserParser.INT, 0); }
		public BreakStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterBreakStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitBreakStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitBreakStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class PriorityContext extends ExpressionContext {
		public TerminalNode LPARENTHESES() { return getToken(BasicParserParser.LPARENTHESES, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPARENTHESES() { return getToken(BasicParserParser.RPARENTHESES, 0); }
		public PriorityContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterPriority(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitPriority(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitPriority(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExitSubStatementContext extends ExpressionContext {
		public TerminalNode EXITSUB() { return getToken(BasicParserParser.EXITSUB, 0); }
		public ExitSubStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterExitSubStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitExitSubStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitExitSubStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ObjectAccessContext extends ExpressionContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode DOT() { return getToken(BasicParserParser.DOT, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public FunccallparamsContext funccallparams() {
			return getRuleContext(FunccallparamsContext.class,0);
		}
		public ObjectAccessContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterObjectAccess(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitObjectAccess(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitObjectAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class StrContext extends ExpressionContext {
		public TerminalNode STRING() { return getToken(BasicParserParser.STRING, 0); }
		public StrContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterStr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitStr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitStr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class WhileExprStatementContext extends ExpressionContext {
		public WhileexpressionContext whileexpression() {
			return getRuleContext(WhileexpressionContext.class,0);
		}
		public WhileExprStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterWhileExprStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitWhileExprStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitWhileExprStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ClassDefStatementContext extends ExpressionContext {
		public DefclassContext defclass() {
			return getRuleContext(DefclassContext.class,0);
		}
		public ClassDefStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassDefStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassDefStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassDefStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class MeSelfContext extends ExpressionContext {
		public TerminalNode ME() { return getToken(BasicParserParser.ME, 0); }
		public MeSelfContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterMeSelf(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitMeSelf(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitMeSelf(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArthmeticDivideContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode DIVIDE() { return getToken(BasicParserParser.DIVIDE, 0); }
		public ArthmeticDivideContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArthmeticDivide(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArthmeticDivide(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArthmeticDivide(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ForExprStatementContext extends ExpressionContext {
		public ForexpressionContext forexpression() {
			return getRuleContext(ForexpressionContext.class,0);
		}
		public ForExprStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterForExprStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitForExprStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitForExprStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArrayDefStatementContext extends ExpressionContext {
		public ArrayContext array() {
			return getRuleContext(ArrayContext.class,0);
		}
		public ArrayDefStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArrayDefStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArrayDefStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArrayDefStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FunctionCallContext extends ExpressionContext {
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public FunccallparamsContext funccallparams() {
			return getRuleContext(FunccallparamsContext.class,0);
		}
		public FunctionCallContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterFunctionCall(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitFunctionCall(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitFunctionCall(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArthmeticMultiplyContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MULTIPLY() { return getToken(BasicParserParser.MULTIPLY, 0); }
		public ArthmeticMultiplyContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArthmeticMultiply(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArthmeticMultiply(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArthmeticMultiply(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class MapDefStatementContext extends ExpressionContext {
		public MapContext map() {
			return getRuleContext(MapContext.class,0);
		}
		public MapDefStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterMapDefStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitMapDefStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitMapDefStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AssignStatementContext extends ExpressionContext {
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public TerminalNode ASSIGN() { return getToken(BasicParserParser.ASSIGN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public AssignStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterAssignStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitAssignStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitAssignStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareGtContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode GT() { return getToken(BasicParserParser.GT, 0); }
		public CompareGtContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareGt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareGt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareGt(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ContinueStatementContext extends ExpressionContext {
		public TerminalNode CONTINUE() { return getToken(BasicParserParser.CONTINUE, 0); }
		public TerminalNode INT() { return getToken(BasicParserParser.INT, 0); }
		public ContinueStatementContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterContinueStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitContinueStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitContinueStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CompareEqContext extends ExpressionContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode EQ() { return getToken(BasicParserParser.EQ, 0); }
		public CompareEqContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterCompareEq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitCompareEq(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitCompareEq(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 8;
		enterRecursionRule(_localctx, 8, RULE_expression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(117);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				{
				_localctx = new PriorityContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(79);
				match(LPARENTHESES);
				setState(80);
				expression(0);
				setState(81);
				match(RPARENTHESES);
				}
				break;
			case 2:
				{
				_localctx = new LogicNotContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(83);
				match(NOT);
				setState(84);
				expression(38);
				}
				break;
			case 3:
				{
				_localctx = new VarDefineExprContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(85);
				assignment();
				}
				break;
			case 4:
				{
				_localctx = new IfExpressionExprContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(86);
				ifexpression();
				}
				break;
			case 5:
				{
				_localctx = new NumContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(87);
				numeric();
				}
				break;
			case 6:
				{
				_localctx = new StrContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(88);
				match(STRING);
				}
				break;
			case 7:
				{
				_localctx = new BoolTrueContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(89);
				match(TRUE);
				}
				break;
			case 8:
				{
				_localctx = new BoolFalseContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(90);
				match(FALSE);
				}
				break;
			case 9:
				{
				_localctx = new MeSelfContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(91);
				match(ME);
				}
				break;
			case 10:
				{
				_localctx = new ForExprStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(92);
				forexpression();
				}
				break;
			case 11:
				{
				_localctx = new ForEachExprStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(93);
				foreachexpr();
				}
				break;
			case 12:
				{
				_localctx = new WhileExprStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(94);
				whileexpression();
				}
				break;
			case 13:
				{
				_localctx = new ClassDefStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(95);
				defclass();
				}
				break;
			case 14:
				{
				_localctx = new ArrayDefStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(96);
				array();
				}
				break;
			case 15:
				{
				_localctx = new MapDefStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(97);
				map();
				}
				break;
			case 16:
				{
				_localctx = new BreakStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(98);
				match(BREAK);
				setState(100);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
				case 1:
					{
					setState(99);
					match(INT);
					}
					break;
				}
				}
				break;
			case 17:
				{
				_localctx = new ContinueStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(102);
				match(CONTINUE);
				setState(104);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
				case 1:
					{
					setState(103);
					match(INT);
					}
					break;
				}
				}
				break;
			case 18:
				{
				_localctx = new ReturnStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(106);
				match(RETURN);
				setState(108);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
				case 1:
					{
					setState(107);
					expression(0);
					}
					break;
				}
				}
				break;
			case 19:
				{
				_localctx = new ExitSubStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(110);
				match(EXITSUB);
				}
				break;
			case 20:
				{
				_localctx = new GetVarExprContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(111);
				match(ID);
				}
				break;
			case 21:
				{
				_localctx = new FunctionCallContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(112);
				match(ID);
				setState(113);
				funccallparams();
				}
				break;
			case 22:
				{
				_localctx = new AssignStatementContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(114);
				match(ID);
				setState(115);
				match(ASSIGN);
				setState(116);
				expression(1);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(176);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(174);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
					case 1:
						{
						_localctx = new ArthmeticMultiplyContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(119);
						if (!(precpred(_ctx, 37))) throw new FailedPredicateException(this, "precpred(_ctx, 37)");
						setState(120);
						match(MULTIPLY);
						setState(121);
						expression(38);
						}
						break;
					case 2:
						{
						_localctx = new ArthmeticDivideContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(122);
						if (!(precpred(_ctx, 36))) throw new FailedPredicateException(this, "precpred(_ctx, 36)");
						setState(123);
						match(DIVIDE);
						setState(124);
						expression(37);
						}
						break;
					case 3:
						{
						_localctx = new ArthmeticModContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(125);
						if (!(precpred(_ctx, 35))) throw new FailedPredicateException(this, "precpred(_ctx, 35)");
						setState(126);
						match(MOD);
						setState(127);
						expression(36);
						}
						break;
					case 4:
						{
						_localctx = new ConcatenateStrStatementContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(128);
						if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)");
						setState(129);
						match(CONCATENATE);
						setState(130);
						expression(35);
						}
						break;
					case 5:
						{
						_localctx = new ArthmeticAddContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(131);
						if (!(precpred(_ctx, 33))) throw new FailedPredicateException(this, "precpred(_ctx, 33)");
						setState(132);
						match(ADD);
						setState(133);
						expression(34);
						}
						break;
					case 6:
						{
						_localctx = new ArthmeticMinusContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(134);
						if (!(precpred(_ctx, 32))) throw new FailedPredicateException(this, "precpred(_ctx, 32)");
						setState(135);
						match(MINUS);
						setState(136);
						expression(33);
						}
						break;
					case 7:
						{
						_localctx = new CompareEqContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(137);
						if (!(precpred(_ctx, 31))) throw new FailedPredicateException(this, "precpred(_ctx, 31)");
						setState(138);
						match(EQ);
						setState(139);
						expression(32);
						}
						break;
					case 8:
						{
						_localctx = new CompareNeqContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(140);
						if (!(precpred(_ctx, 30))) throw new FailedPredicateException(this, "precpred(_ctx, 30)");
						setState(141);
						match(NEQ);
						setState(142);
						expression(31);
						}
						break;
					case 9:
						{
						_localctx = new CompareGtContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(143);
						if (!(precpred(_ctx, 29))) throw new FailedPredicateException(this, "precpred(_ctx, 29)");
						setState(144);
						match(GT);
						setState(145);
						expression(30);
						}
						break;
					case 10:
						{
						_localctx = new CompareLtContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(146);
						if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)");
						setState(147);
						match(LT);
						setState(148);
						expression(29);
						}
						break;
					case 11:
						{
						_localctx = new CompareLteContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(149);
						if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)");
						setState(150);
						match(LTE);
						setState(151);
						expression(28);
						}
						break;
					case 12:
						{
						_localctx = new CompareGteContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(152);
						if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)");
						setState(153);
						match(GTE);
						setState(154);
						expression(27);
						}
						break;
					case 13:
						{
						_localctx = new LogicBitAndContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(155);
						if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
						setState(156);
						match(BITAND);
						setState(157);
						expression(26);
						}
						break;
					case 14:
						{
						_localctx = new LogicXorContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(158);
						if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
						setState(159);
						match(XOR);
						setState(160);
						expression(25);
						}
						break;
					case 15:
						{
						_localctx = new LogicBitOrContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(161);
						if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
						setState(162);
						match(BITOR);
						setState(163);
						expression(24);
						}
						break;
					case 16:
						{
						_localctx = new LogicAndContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(164);
						if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
						setState(165);
						match(AND);
						setState(166);
						expression(23);
						}
						break;
					case 17:
						{
						_localctx = new LogicOrContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(167);
						if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
						setState(168);
						match(OR);
						setState(169);
						expression(22);
						}
						break;
					case 18:
						{
						_localctx = new ObjectAccessContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(170);
						if (!(precpred(_ctx, 39))) throw new FailedPredicateException(this, "precpred(_ctx, 39)");
						setState(171);
						match(DOT);
						setState(172);
						match(ID);
						setState(173);
						funccallparams();
						}
						break;
					}
					} 
				}
				setState(178);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunccallparamsContext extends ParserRuleContext {
		public FunccallparamsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funccallparams; }
	 
		public FunccallparamsContext() { }
		public void copyFrom(FunccallparamsContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FuncCallParamsExprContext extends FunccallparamsContext {
		public TerminalNode LPARENTHESES() { return getToken(BasicParserParser.LPARENTHESES, 0); }
		public TerminalNode RPARENTHESES() { return getToken(BasicParserParser.RPARENTHESES, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public FuncCallParamsExprContext(FunccallparamsContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterFuncCallParamsExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitFuncCallParamsExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitFuncCallParamsExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunccallparamsContext funccallparams() throws RecognitionException {
		FunccallparamsContext _localctx = new FunccallparamsContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_funccallparams);
		int _la;
		try {
			_localctx = new FuncCallParamsExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(179);
			match(LPARENTHESES);
			setState(188);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(180);
				expression(0);
				setState(185);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(181);
					match(T__0);
					setState(182);
					expression(0);
					}
					}
					setState(187);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(190);
			match(RPARENTHESES);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IfexpressionContext extends ParserRuleContext {
		public IfexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifexpression; }
	 
		public IfexpressionContext() { }
		public void copyFrom(IfexpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IfExprContext extends IfexpressionContext {
		public TerminalNode IF() { return getToken(BasicParserParser.IF, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode THEN() { return getToken(BasicParserParser.THEN, 0); }
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public TerminalNode ENDIF() { return getToken(BasicParserParser.ENDIF, 0); }
		public List<ElseifexpressionContext> elseifexpression() {
			return getRuleContexts(ElseifexpressionContext.class);
		}
		public ElseifexpressionContext elseifexpression(int i) {
			return getRuleContext(ElseifexpressionContext.class,i);
		}
		public ElseexpressionContext elseexpression() {
			return getRuleContext(ElseexpressionContext.class,0);
		}
		public IfExprContext(IfexpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterIfExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitIfExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitIfExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfexpressionContext ifexpression() throws RecognitionException {
		IfexpressionContext _localctx = new IfexpressionContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_ifexpression);
		int _la;
		try {
			_localctx = new IfExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			match(IF);
			setState(193);
			expression(0);
			setState(194);
			match(THEN);
			setState(195);
			match(NEWLINE);
			setState(196);
			process();
			setState(197);
			match(NEWLINE);
			setState(201);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ELSEIF) {
				{
				{
				setState(198);
				elseifexpression();
				}
				}
				setState(203);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(205);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ELSE) {
				{
				setState(204);
				elseexpression();
				}
			}

			setState(207);
			match(ENDIF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ElseifexpressionContext extends ParserRuleContext {
		public ElseifexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_elseifexpression; }
	 
		public ElseifexpressionContext() { }
		public void copyFrom(ElseifexpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ElseIfExprContext extends ElseifexpressionContext {
		public TerminalNode ELSEIF() { return getToken(BasicParserParser.ELSEIF, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode THEN() { return getToken(BasicParserParser.THEN, 0); }
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public ElseIfExprContext(ElseifexpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterElseIfExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitElseIfExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitElseIfExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ElseifexpressionContext elseifexpression() throws RecognitionException {
		ElseifexpressionContext _localctx = new ElseifexpressionContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_elseifexpression);
		int _la;
		try {
			_localctx = new ElseIfExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(209);
			match(ELSEIF);
			setState(210);
			expression(0);
			setState(211);
			match(THEN);
			setState(212);
			match(NEWLINE);
			setState(214);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(213);
				process();
				}
			}

			setState(216);
			match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ElseexpressionContext extends ParserRuleContext {
		public ElseexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_elseexpression; }
	 
		public ElseexpressionContext() { }
		public void copyFrom(ElseexpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ElseExprContext extends ElseexpressionContext {
		public TerminalNode ELSE() { return getToken(BasicParserParser.ELSE, 0); }
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public ElseExprContext(ElseexpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterElseExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitElseExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitElseExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ElseexpressionContext elseexpression() throws RecognitionException {
		ElseexpressionContext _localctx = new ElseexpressionContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_elseexpression);
		int _la;
		try {
			_localctx = new ElseExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(218);
			match(ELSE);
			setState(219);
			match(NEWLINE);
			setState(221);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(220);
				process();
				}
			}

			setState(223);
			match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ForexpressionContext extends ParserRuleContext {
		public ForexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_forexpression; }
	 
		public ForexpressionContext() { }
		public void copyFrom(ForexpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ForExprContext extends ForexpressionContext {
		public Token t;
		public TerminalNode FOR() { return getToken(BasicParserParser.FOR, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public TerminalNode ASSIGN() { return getToken(BasicParserParser.ASSIGN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode NEXT() { return getToken(BasicParserParser.NEXT, 0); }
		public TerminalNode TO() { return getToken(BasicParserParser.TO, 0); }
		public TerminalNode DOWNTO() { return getToken(BasicParserParser.DOWNTO, 0); }
		public TerminalNode STEP() { return getToken(BasicParserParser.STEP, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public ForExprContext(ForexpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterForExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitForExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitForExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ForexpressionContext forexpression() throws RecognitionException {
		ForexpressionContext _localctx = new ForexpressionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_forexpression);
		int _la;
		try {
			_localctx = new ForExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(225);
			match(FOR);
			setState(226);
			match(ID);
			setState(227);
			match(ASSIGN);
			setState(228);
			expression(0);
			setState(229);
			((ForExprContext)_localctx).t = _input.LT(1);
			_la = _input.LA(1);
			if ( !(_la==TO || _la==DOWNTO) ) {
				((ForExprContext)_localctx).t = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(230);
			expression(0);
			setState(233);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STEP) {
				{
				setState(231);
				match(STEP);
				setState(232);
				expression(0);
				}
			}

			setState(235);
			match(NEWLINE);
			setState(237);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(236);
				process();
				}
			}

			setState(239);
			match(NEWLINE);
			setState(240);
			match(NEXT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ForeachexprContext extends ParserRuleContext {
		public ForeachexprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_foreachexpr; }
	 
		public ForeachexprContext() { }
		public void copyFrom(ForeachexprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ForEachExpressionContext extends ForeachexprContext {
		public TerminalNode FOREACH() { return getToken(BasicParserParser.FOREACH, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public TerminalNode AS() { return getToken(BasicParserParser.AS, 0); }
		public AstypeContext astype() {
			return getRuleContext(AstypeContext.class,0);
		}
		public TerminalNode OF() { return getToken(BasicParserParser.OF, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode ENDFOREACH() { return getToken(BasicParserParser.ENDFOREACH, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public ForEachExpressionContext(ForeachexprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterForEachExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitForEachExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitForEachExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ForeachexprContext foreachexpr() throws RecognitionException {
		ForeachexprContext _localctx = new ForeachexprContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_foreachexpr);
		int _la;
		try {
			_localctx = new ForEachExpressionContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(242);
			match(FOREACH);
			setState(243);
			match(ID);
			setState(244);
			match(AS);
			setState(245);
			astype();
			setState(246);
			match(OF);
			setState(247);
			expression(0);
			setState(248);
			match(NEWLINE);
			setState(250);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(249);
				process();
				}
			}

			setState(252);
			match(NEWLINE);
			setState(253);
			match(ENDFOREACH);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class WhileexpressionContext extends ParserRuleContext {
		public WhileexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whileexpression; }
	 
		public WhileexpressionContext() { }
		public void copyFrom(WhileexpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class WhileExprContext extends WhileexpressionContext {
		public TerminalNode WHILE() { return getToken(BasicParserParser.WHILE, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode ENDWHILE() { return getToken(BasicParserParser.ENDWHILE, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public WhileExprContext(WhileexpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterWhileExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitWhileExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitWhileExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhileexpressionContext whileexpression() throws RecognitionException {
		WhileexpressionContext _localctx = new WhileexpressionContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_whileexpression);
		int _la;
		try {
			_localctx = new WhileExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(255);
			match(WHILE);
			setState(256);
			expression(0);
			setState(257);
			match(NEWLINE);
			setState(259);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(258);
				process();
				}
			}

			setState(261);
			match(NEWLINE);
			setState(262);
			match(ENDWHILE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DoloopContext extends ParserRuleContext {
		public DoloopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_doloop; }
	 
		public DoloopContext() { }
		public void copyFrom(DoloopContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoLoopExprContext extends DoloopContext {
		public TerminalNode DO() { return getToken(BasicParserParser.DO, 0); }
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode WHILE() { return getToken(BasicParserParser.WHILE, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode LOOP() { return getToken(BasicParserParser.LOOP, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public DoLoopExprContext(DoloopContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterDoLoopExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitDoLoopExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitDoLoopExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DoloopContext doloop() throws RecognitionException {
		DoloopContext _localctx = new DoloopContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_doloop);
		int _la;
		try {
			_localctx = new DoLoopExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(264);
			match(DO);
			setState(265);
			match(NEWLINE);
			setState(267);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(266);
				process();
				}
			}

			setState(269);
			match(NEWLINE);
			setState(270);
			match(WHILE);
			setState(271);
			expression(0);
			setState(272);
			match(LOOP);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeffuncparamContext extends ParserRuleContext {
		public DeffuncparamContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deffuncparam; }
	 
		public DeffuncparamContext() { }
		public void copyFrom(DeffuncparamContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DefFuncParamExprContext extends DeffuncparamContext {
		public TerminalNode LPARENTHESES() { return getToken(BasicParserParser.LPARENTHESES, 0); }
		public TerminalNode RPARENTHESES() { return getToken(BasicParserParser.RPARENTHESES, 0); }
		public List<DefparamContext> defparam() {
			return getRuleContexts(DefparamContext.class);
		}
		public DefparamContext defparam(int i) {
			return getRuleContext(DefparamContext.class,i);
		}
		public DefFuncParamExprContext(DeffuncparamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterDefFuncParamExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitDefFuncParamExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitDefFuncParamExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeffuncparamContext deffuncparam() throws RecognitionException {
		DeffuncparamContext _localctx = new DeffuncparamContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_deffuncparam);
		int _la;
		try {
			_localctx = new DefFuncParamExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(274);
			match(LPARENTHESES);
			setState(283);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ID) {
				{
				setState(275);
				defparam();
				setState(280);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(276);
					match(T__0);
					setState(277);
					defparam();
					}
					}
					setState(282);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(285);
			match(RPARENTHESES);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SubContext extends ParserRuleContext {
		public SubContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sub; }
	 
		public SubContext() { }
		public void copyFrom(SubContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class SubroutineDefineContext extends SubContext {
		public TerminalNode SUB() { return getToken(BasicParserParser.SUB, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public DeffuncparamContext deffuncparam() {
			return getRuleContext(DeffuncparamContext.class,0);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode ENDSUB() { return getToken(BasicParserParser.ENDSUB, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public SubroutineDefineContext(SubContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterSubroutineDefine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitSubroutineDefine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitSubroutineDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubContext sub() throws RecognitionException {
		SubContext _localctx = new SubContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_sub);
		int _la;
		try {
			_localctx = new SubroutineDefineContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			match(SUB);
			setState(288);
			match(ID);
			setState(289);
			deffuncparam();
			setState(290);
			match(NEWLINE);
			setState(292);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(291);
				process();
				}
			}

			setState(294);
			match(NEWLINE);
			setState(295);
			match(ENDSUB);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FuncContext extends ParserRuleContext {
		public FuncContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_func; }
	 
		public FuncContext() { }
		public void copyFrom(FuncContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FunctionDefineContext extends FuncContext {
		public TerminalNode FUNCTION() { return getToken(BasicParserParser.FUNCTION, 0); }
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public DeffuncparamContext deffuncparam() {
			return getRuleContext(DeffuncparamContext.class,0);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode ENDFUNCTION() { return getToken(BasicParserParser.ENDFUNCTION, 0); }
		public ProcessContext process() {
			return getRuleContext(ProcessContext.class,0);
		}
		public FunctionDefineContext(FuncContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterFunctionDefine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitFunctionDefine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitFunctionDefine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncContext func() throws RecognitionException {
		FuncContext _localctx = new FuncContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_func);
		int _la;
		try {
			_localctx = new FunctionDefineContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(297);
			match(FUNCTION);
			setState(298);
			match(ID);
			setState(299);
			deffuncparam();
			setState(300);
			match(NEWLINE);
			setState(302);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(301);
				process();
				}
			}

			setState(304);
			match(NEWLINE);
			setState(305);
			match(ENDFUNCTION);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ImpllistContext extends ParserRuleContext {
		public ImpllistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_impllist; }
	 
		public ImpllistContext() { }
		public void copyFrom(ImpllistContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ImplListExprContext extends ImpllistContext {
		public List<TerminalNode> ID() { return getTokens(BasicParserParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(BasicParserParser.ID, i);
		}
		public ImplListExprContext(ImpllistContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterImplListExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitImplListExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitImplListExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImpllistContext impllist() throws RecognitionException {
		ImpllistContext _localctx = new ImpllistContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_impllist);
		int _la;
		try {
			_localctx = new ImplListExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(307);
			match(ID);
			setState(312);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(308);
				match(T__0);
				setState(309);
				match(ID);
				}
				}
				setState(314);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DefclassContext extends ParserRuleContext {
		public DefclassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_defclass; }
	 
		public DefclassContext() { }
		public void copyFrom(DefclassContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DefClassExprContext extends DefclassContext {
		public TerminalNode CLASS() { return getToken(BasicParserParser.CLASS, 0); }
		public List<TerminalNode> ID() { return getTokens(BasicParserParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(BasicParserParser.ID, i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public TerminalNode ENDCLASS() { return getToken(BasicParserParser.ENDCLASS, 0); }
		public TerminalNode INHERITS() { return getToken(BasicParserParser.INHERITS, 0); }
		public TerminalNode IMPLEMENTS() { return getToken(BasicParserParser.IMPLEMENTS, 0); }
		public ImpllistContext impllist() {
			return getRuleContext(ImpllistContext.class,0);
		}
		public ClassbodyContext classbody() {
			return getRuleContext(ClassbodyContext.class,0);
		}
		public DefClassExprContext(DefclassContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterDefClassExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitDefClassExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitDefClassExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DefclassContext defclass() throws RecognitionException {
		DefclassContext _localctx = new DefclassContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_defclass);
		int _la;
		try {
			_localctx = new DefClassExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(315);
			match(CLASS);
			setState(316);
			match(ID);
			setState(319);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==INHERITS) {
				{
				setState(317);
				match(INHERITS);
				setState(318);
				match(ID);
				}
			}

			setState(323);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==IMPLEMENTS) {
				{
				setState(321);
				match(IMPLEMENTS);
				setState(322);
				impllist();
				}
			}

			setState(325);
			match(NEWLINE);
			setState(327);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((((_la - 46)) & ~0x3f) == 0 && ((1L << (_la - 46)) & 68042757L) != 0)) {
				{
				setState(326);
				classbody();
				}
			}

			setState(329);
			match(NEWLINE);
			setState(330);
			match(ENDCLASS);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AccessclassContext extends ParserRuleContext {
		public TerminalNode PUBLIC() { return getToken(BasicParserParser.PUBLIC, 0); }
		public TerminalNode PROTECTED() { return getToken(BasicParserParser.PROTECTED, 0); }
		public TerminalNode PRIVATE() { return getToken(BasicParserParser.PRIVATE, 0); }
		public AccessclassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_accessclass; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterAccessclass(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitAccessclass(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitAccessclass(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AccessclassContext accessclass() throws RecognitionException {
		AccessclassContext _localctx = new AccessclassContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_accessclass);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(332);
			_la = _input.LA(1);
			if ( !(((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 7L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClasssubContext extends ParserRuleContext {
		public ClasssubContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classsub; }
	 
		public ClasssubContext() { }
		public void copyFrom(ClasssubContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ClassSubExprContext extends ClasssubContext {
		public SubContext sub() {
			return getRuleContext(SubContext.class,0);
		}
		public AccessclassContext accessclass() {
			return getRuleContext(AccessclassContext.class,0);
		}
		public TerminalNode SHARED() { return getToken(BasicParserParser.SHARED, 0); }
		public ClassSubExprContext(ClasssubContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassSubExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassSubExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassSubExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClasssubContext classsub() throws RecognitionException {
		ClasssubContext _localctx = new ClasssubContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_classsub);
		int _la;
		try {
			_localctx = new ClassSubExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(335);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 7L) != 0)) {
				{
				setState(334);
				accessclass();
				}
			}

			setState(338);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SHARED) {
				{
				setState(337);
				match(SHARED);
				}
			}

			setState(340);
			sub();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassfuncContext extends ParserRuleContext {
		public ClassfuncContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classfunc; }
	 
		public ClassfuncContext() { }
		public void copyFrom(ClassfuncContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ClassFuncExprContext extends ClassfuncContext {
		public FuncContext func() {
			return getRuleContext(FuncContext.class,0);
		}
		public AccessclassContext accessclass() {
			return getRuleContext(AccessclassContext.class,0);
		}
		public TerminalNode SHARED() { return getToken(BasicParserParser.SHARED, 0); }
		public ClassFuncExprContext(ClassfuncContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassFuncExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassFuncExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassFuncExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassfuncContext classfunc() throws RecognitionException {
		ClassfuncContext _localctx = new ClassfuncContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_classfunc);
		int _la;
		try {
			_localctx = new ClassFuncExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(343);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 7L) != 0)) {
				{
				setState(342);
				accessclass();
				}
			}

			setState(346);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SHARED) {
				{
				setState(345);
				match(SHARED);
				}
			}

			setState(348);
			func();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassvarContext extends ParserRuleContext {
		public ClassvarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classvar; }
	 
		public ClassvarContext() { }
		public void copyFrom(ClassvarContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ClassVarExprContext extends ClassvarContext {
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public AccessclassContext accessclass() {
			return getRuleContext(AccessclassContext.class,0);
		}
		public TerminalNode SHARED() { return getToken(BasicParserParser.SHARED, 0); }
		public ClassVarExprContext(ClassvarContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassVarExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassVarExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassVarExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassvarContext classvar() throws RecognitionException {
		ClassvarContext _localctx = new ClassvarContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_classvar);
		int _la;
		try {
			_localctx = new ClassVarExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(351);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 7L) != 0)) {
				{
				setState(350);
				accessclass();
				}
			}

			setState(354);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SHARED) {
				{
				setState(353);
				match(SHARED);
				}
			}

			setState(356);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassblockContext extends ParserRuleContext {
		public ClasssubContext classsub() {
			return getRuleContext(ClasssubContext.class,0);
		}
		public ClassfuncContext classfunc() {
			return getRuleContext(ClassfuncContext.class,0);
		}
		public ClassvarContext classvar() {
			return getRuleContext(ClassvarContext.class,0);
		}
		public ClassblockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classblock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassblock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassblock(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassblock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassblockContext classblock() throws RecognitionException {
		ClassblockContext _localctx = new ClassblockContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_classblock);
		try {
			setState(361);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(358);
				classsub();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(359);
				classfunc();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(360);
				classvar();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassbodyContext extends ParserRuleContext {
		public ClassbodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classbody; }
	 
		public ClassbodyContext() { }
		public void copyFrom(ClassbodyContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ClassBodyExprContext extends ClassbodyContext {
		public ClassblockContext classblock() {
			return getRuleContext(ClassblockContext.class,0);
		}
		public TerminalNode NEWLINE() { return getToken(BasicParserParser.NEWLINE, 0); }
		public ClassbodyContext classbody() {
			return getRuleContext(ClassbodyContext.class,0);
		}
		public ClassBodyExprContext(ClassbodyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterClassBodyExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitClassBodyExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitClassBodyExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassbodyContext classbody() throws RecognitionException {
		ClassbodyContext _localctx = new ClassbodyContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_classbody);
		try {
			_localctx = new ClassBodyExprContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(363);
			classblock();
			setState(366);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
			case 1:
				{
				setState(364);
				match(NEWLINE);
				setState(365);
				classbody();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArrayContext extends ParserRuleContext {
		public ArrayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_array; }
	 
		public ArrayContext() { }
		public void copyFrom(ArrayContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArrayDefContext extends ArrayContext {
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public ArrayDefContext(ArrayContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArrayDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArrayDef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArrayDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArrayContext array() throws RecognitionException {
		ArrayContext _localctx = new ArrayContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_array);
		int _la;
		try {
			_localctx = new ArrayDefContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(368);
			match(T__1);
			setState(377);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 89000004144865364L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 483L) != 0)) {
				{
				setState(369);
				expression(0);
				setState(374);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==NEWLINE) {
					{
					{
					setState(370);
					match(NEWLINE);
					setState(371);
					expression(0);
					}
					}
					setState(376);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(379);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MapContext extends ParserRuleContext {
		public MapContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_map; }
	 
		public MapContext() { }
		public void copyFrom(MapContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class MapDefContext extends MapContext {
		public List<TerminalNode> STRING() { return getTokens(BasicParserParser.STRING); }
		public TerminalNode STRING(int i) {
			return getToken(BasicParserParser.STRING, i);
		}
		public List<TerminalNode> MAP_ASSIGN() { return getTokens(BasicParserParser.MAP_ASSIGN); }
		public TerminalNode MAP_ASSIGN(int i) {
			return getToken(BasicParserParser.MAP_ASSIGN, i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(BasicParserParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(BasicParserParser.NEWLINE, i);
		}
		public MapDefContext(MapContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterMapDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitMapDef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitMapDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapContext map() throws RecognitionException {
		MapContext _localctx = new MapContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_map);
		int _la;
		try {
			_localctx = new MapDefContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(381);
			match(T__3);
			setState(394);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STRING) {
				{
				setState(382);
				match(STRING);
				setState(383);
				match(MAP_ASSIGN);
				setState(384);
				expression(0);
				setState(391);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==NEWLINE) {
					{
					{
					setState(385);
					match(NEWLINE);
					setState(386);
					match(STRING);
					setState(387);
					match(MAP_ASSIGN);
					setState(388);
					expression(0);
					}
					}
					setState(393);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(396);
			match(T__4);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArraytypeContext extends ParserRuleContext {
		public ArraytypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arraytype; }
	 
		public ArraytypeContext() { }
		public void copyFrom(ArraytypeContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ArrayTypeDefContext extends ArraytypeContext {
		public List<TerminalNode> ARRAY_SYMBOL() { return getTokens(BasicParserParser.ARRAY_SYMBOL); }
		public TerminalNode ARRAY_SYMBOL(int i) {
			return getToken(BasicParserParser.ARRAY_SYMBOL, i);
		}
		public ArrayTypeDefContext(ArraytypeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterArrayTypeDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitArrayTypeDef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitArrayTypeDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArraytypeContext arraytype() throws RecognitionException {
		ArraytypeContext _localctx = new ArraytypeContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_arraytype);
		try {
			int _alt;
			_localctx = new ArrayTypeDefContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(401);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(398);
					match(ARRAY_SYMBOL);
					}
					} 
				}
				setState(403);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AstypeContext extends ParserRuleContext {
		public AstypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_astype; }
	 
		public AstypeContext() { }
		public void copyFrom(AstypeContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AsTypeDefContext extends AstypeContext {
		public TerminalNode ID() { return getToken(BasicParserParser.ID, 0); }
		public ArraytypeContext arraytype() {
			return getRuleContext(ArraytypeContext.class,0);
		}
		public AsTypeDefContext(AstypeContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).enterAsTypeDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BasicParserListener ) ((BasicParserListener)listener).exitAsTypeDef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof BasicParserVisitor ) return ((BasicParserVisitor<? extends T>)visitor).visitAsTypeDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AstypeContext astype() throws RecognitionException {
		AstypeContext _localctx = new AstypeContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_astype);
		try {
			_localctx = new AsTypeDefContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(404);
			match(ID);
			setState(405);
			arraytype();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 4:
			return expression_sempred((ExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 37);
		case 1:
			return precpred(_ctx, 36);
		case 2:
			return precpred(_ctx, 35);
		case 3:
			return precpred(_ctx, 34);
		case 4:
			return precpred(_ctx, 33);
		case 5:
			return precpred(_ctx, 32);
		case 6:
			return precpred(_ctx, 31);
		case 7:
			return precpred(_ctx, 30);
		case 8:
			return precpred(_ctx, 29);
		case 9:
			return precpred(_ctx, 28);
		case 10:
			return precpred(_ctx, 27);
		case 11:
			return precpred(_ctx, 26);
		case 12:
			return precpred(_ctx, 25);
		case 13:
			return precpred(_ctx, 24);
		case 14:
			return precpred(_ctx, 23);
		case 15:
			return precpred(_ctx, 22);
		case 16:
			return precpred(_ctx, 21);
		case 17:
			return precpred(_ctx, 39);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001M\u0198\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
		"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
		"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
		"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
		"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
		"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
		"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
		"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
		"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
		"\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0003\u0001A\b\u0001\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0003\u0002H\b\u0002\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0003\u0003M\b\u0003\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0003\u0004e\b\u0004\u0001\u0004\u0001\u0004"+
		"\u0003\u0004i\b\u0004\u0001\u0004\u0001\u0004\u0003\u0004m\b\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0003\u0004v\b\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0005\u0004\u00af\b\u0004\n"+
		"\u0004\f\u0004\u00b2\t\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
		"\u0005\u0005\u0005\u00b8\b\u0005\n\u0005\f\u0005\u00bb\t\u0005\u0003\u0005"+
		"\u00bd\b\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+
		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u00c8\b\u0006"+
		"\n\u0006\f\u0006\u00cb\t\u0006\u0001\u0006\u0003\u0006\u00ce\b\u0006\u0001"+
		"\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
		"\u0007\u0003\u0007\u00d7\b\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+
		"\b\u0001\b\u0003\b\u00de\b\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001"+
		"\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u00ea\b\t\u0001\t\u0001\t\u0003"+
		"\t\u00ee\b\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+
		"\n\u0001\n\u0001\n\u0001\n\u0003\n\u00fb\b\n\u0001\n\u0001\n\u0001\n\u0001"+
		"\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0104\b\u000b\u0001"+
		"\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0003\f\u010c\b"+
		"\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001"+
		"\r\u0005\r\u0117\b\r\n\r\f\r\u011a\t\r\u0003\r\u011c\b\r\u0001\r\u0001"+
		"\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003\u000e"+
		"\u0125\b\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u012f\b\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0005\u0010"+
		"\u0137\b\u0010\n\u0010\f\u0010\u013a\t\u0010\u0001\u0011\u0001\u0011\u0001"+
		"\u0011\u0001\u0011\u0003\u0011\u0140\b\u0011\u0001\u0011\u0001\u0011\u0003"+
		"\u0011\u0144\b\u0011\u0001\u0011\u0001\u0011\u0003\u0011\u0148\b\u0011"+
		"\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013"+
		"\u0003\u0013\u0150\b\u0013\u0001\u0013\u0003\u0013\u0153\b\u0013\u0001"+
		"\u0013\u0001\u0013\u0001\u0014\u0003\u0014\u0158\b\u0014\u0001\u0014\u0003"+
		"\u0014\u015b\b\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0003\u0015\u0160"+
		"\b\u0015\u0001\u0015\u0003\u0015\u0163\b\u0015\u0001\u0015\u0001\u0015"+
		"\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u016a\b\u0016\u0001\u0017"+
		"\u0001\u0017\u0001\u0017\u0003\u0017\u016f\b\u0017\u0001\u0018\u0001\u0018"+
		"\u0001\u0018\u0001\u0018\u0005\u0018\u0175\b\u0018\n\u0018\f\u0018\u0178"+
		"\t\u0018\u0003\u0018\u017a\b\u0018\u0001\u0018\u0001\u0018\u0001\u0019"+
		"\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
		"\u0001\u0019\u0005\u0019\u0186\b\u0019\n\u0019\f\u0019\u0189\t\u0019\u0003"+
		"\u0019\u018b\b\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0005\u001a\u0190"+
		"\b\u001a\n\u001a\f\u001a\u0193\t\u001a\u0001\u001b\u0001\u001b\u0001\u001b"+
		"\u0001\u001b\u0000\u0001\b\u001c\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010"+
		"\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.0246\u0000\u0003\u0001"+
		"\u0000IJ\u0001\u0000$%\u0001\u0000?A\u01c9\u00008\u0001\u0000\u0000\u0000"+
		"\u0002:\u0001\u0000\u0000\u0000\u0004B\u0001\u0000\u0000\u0000\u0006I"+
		"\u0001\u0000\u0000\u0000\bu\u0001\u0000\u0000\u0000\n\u00b3\u0001\u0000"+
		"\u0000\u0000\f\u00c0\u0001\u0000\u0000\u0000\u000e\u00d1\u0001\u0000\u0000"+
		"\u0000\u0010\u00da\u0001\u0000\u0000\u0000\u0012\u00e1\u0001\u0000\u0000"+
		"\u0000\u0014\u00f2\u0001\u0000\u0000\u0000\u0016\u00ff\u0001\u0000\u0000"+
		"\u0000\u0018\u0108\u0001\u0000\u0000\u0000\u001a\u0112\u0001\u0000\u0000"+
		"\u0000\u001c\u011f\u0001\u0000\u0000\u0000\u001e\u0129\u0001\u0000\u0000"+
		"\u0000 \u0133\u0001\u0000\u0000\u0000\"\u013b\u0001\u0000\u0000\u0000"+
		"$\u014c\u0001\u0000\u0000\u0000&\u014f\u0001\u0000\u0000\u0000(\u0157"+
		"\u0001\u0000\u0000\u0000*\u015f\u0001\u0000\u0000\u0000,\u0169\u0001\u0000"+
		"\u0000\u0000.\u016b\u0001\u0000\u0000\u00000\u0170\u0001\u0000\u0000\u0000"+
		"2\u017d\u0001\u0000\u0000\u00004\u0191\u0001\u0000\u0000\u00006\u0194"+
		"\u0001\u0000\u0000\u000089\u0007\u0000\u0000\u00009\u0001\u0001\u0000"+
		"\u0000\u0000:;\u0005\u0006\u0000\u0000;<\u0005H\u0000\u0000<=\u0005\u0007"+
		"\u0000\u0000=@\u00036\u001b\u0000>?\u0005\u001c\u0000\u0000?A\u0003\b"+
		"\u0004\u0000@>\u0001\u0000\u0000\u0000@A\u0001\u0000\u0000\u0000A\u0003"+
		"\u0001\u0000\u0000\u0000BC\u0005H\u0000\u0000CD\u0005\u0007\u0000\u0000"+
		"DG\u0005H\u0000\u0000EF\u0005\u001c\u0000\u0000FH\u0003\b\u0004\u0000"+
		"GE\u0001\u0000\u0000\u0000GH\u0001\u0000\u0000\u0000H\u0005\u0001\u0000"+
		"\u0000\u0000IL\u0003\b\u0004\u0000JK\u0005K\u0000\u0000KM\u0003\u0006"+
		"\u0003\u0000LJ\u0001\u0000\u0000\u0000LM\u0001\u0000\u0000\u0000M\u0007"+
		"\u0001\u0000\u0000\u0000NO\u0006\u0004\uffff\uffff\u0000OP\u0005\r\u0000"+
		"\u0000PQ\u0003\b\u0004\u0000QR\u0005\u000e\u0000\u0000Rv\u0001\u0000\u0000"+
		"\u0000ST\u0005\u0014\u0000\u0000Tv\u0003\b\u0004&Uv\u0003\u0002\u0001"+
		"\u0000Vv\u0003\f\u0006\u0000Wv\u0003\u0000\u0000\u0000Xv\u0005G\u0000"+
		"\u0000Yv\u00054\u0000\u0000Zv\u00055\u0000\u0000[v\u0005B\u0000\u0000"+
		"\\v\u0003\u0012\t\u0000]v\u0003\u0014\n\u0000^v\u0003\u0016\u000b\u0000"+
		"_v\u0003\"\u0011\u0000`v\u00030\u0018\u0000av\u00032\u0019\u0000bd\u0005"+
		",\u0000\u0000ce\u0005I\u0000\u0000dc\u0001\u0000\u0000\u0000de\u0001\u0000"+
		"\u0000\u0000ev\u0001\u0000\u0000\u0000fh\u0005-\u0000\u0000gi\u0005I\u0000"+
		"\u0000hg\u0001\u0000\u0000\u0000hi\u0001\u0000\u0000\u0000iv\u0001\u0000"+
		"\u0000\u0000jl\u00052\u0000\u0000km\u0003\b\u0004\u0000lk\u0001\u0000"+
		"\u0000\u0000lm\u0001\u0000\u0000\u0000mv\u0001\u0000\u0000\u0000nv\u0005"+
		"3\u0000\u0000ov\u0005H\u0000\u0000pq\u0005H\u0000\u0000qv\u0003\n\u0005"+
		"\u0000rs\u0005H\u0000\u0000st\u0005\u001c\u0000\u0000tv\u0003\b\u0004"+
		"\u0001uN\u0001\u0000\u0000\u0000uS\u0001\u0000\u0000\u0000uU\u0001\u0000"+
		"\u0000\u0000uV\u0001\u0000\u0000\u0000uW\u0001\u0000\u0000\u0000uX\u0001"+
		"\u0000\u0000\u0000uY\u0001\u0000\u0000\u0000uZ\u0001\u0000\u0000\u0000"+
		"u[\u0001\u0000\u0000\u0000u\\\u0001\u0000\u0000\u0000u]\u0001\u0000\u0000"+
		"\u0000u^\u0001\u0000\u0000\u0000u_\u0001\u0000\u0000\u0000u`\u0001\u0000"+
		"\u0000\u0000ua\u0001\u0000\u0000\u0000ub\u0001\u0000\u0000\u0000uf\u0001"+
		"\u0000\u0000\u0000uj\u0001\u0000\u0000\u0000un\u0001\u0000\u0000\u0000"+
		"uo\u0001\u0000\u0000\u0000up\u0001\u0000\u0000\u0000ur\u0001\u0000\u0000"+
		"\u0000v\u00b0\u0001\u0000\u0000\u0000wx\n%\u0000\u0000xy\u0005\n\u0000"+
		"\u0000y\u00af\u0003\b\u0004&z{\n$\u0000\u0000{|\u0005\u000b\u0000\u0000"+
		"|\u00af\u0003\b\u0004%}~\n#\u0000\u0000~\u007f\u0005\f\u0000\u0000\u007f"+
		"\u00af\u0003\b\u0004$\u0080\u0081\n\"\u0000\u0000\u0081\u0082\u0005\u0015"+
		"\u0000\u0000\u0082\u00af\u0003\b\u0004#\u0083\u0084\n!\u0000\u0000\u0084"+
		"\u0085\u0005\b\u0000\u0000\u0085\u00af\u0003\b\u0004\"\u0086\u0087\n "+
		"\u0000\u0000\u0087\u0088\u0005\t\u0000\u0000\u0088\u00af\u0003\b\u0004"+
		"!\u0089\u008a\n\u001f\u0000\u0000\u008a\u008b\u0005\u0016\u0000\u0000"+
		"\u008b\u00af\u0003\b\u0004 \u008c\u008d\n\u001e\u0000\u0000\u008d\u008e"+
		"\u0005\u0017\u0000\u0000\u008e\u00af\u0003\b\u0004\u001f\u008f\u0090\n"+
		"\u001d\u0000\u0000\u0090\u0091\u0005\u0018\u0000\u0000\u0091\u00af\u0003"+
		"\b\u0004\u001e\u0092\u0093\n\u001c\u0000\u0000\u0093\u0094\u0005\u0019"+
		"\u0000\u0000\u0094\u00af\u0003\b\u0004\u001d\u0095\u0096\n\u001b\u0000"+
		"\u0000\u0096\u0097\u0005\u001b\u0000\u0000\u0097\u00af\u0003\b\u0004\u001c"+
		"\u0098\u0099\n\u001a\u0000\u0000\u0099\u009a\u0005\u001a\u0000\u0000\u009a"+
		"\u00af\u0003\b\u0004\u001b\u009b\u009c\n\u0019\u0000\u0000\u009c\u009d"+
		"\u0005\u000f\u0000\u0000\u009d\u00af\u0003\b\u0004\u001a\u009e\u009f\n"+
		"\u0018\u0000\u0000\u009f\u00a0\u0005\u0013\u0000\u0000\u00a0\u00af\u0003"+
		"\b\u0004\u0019\u00a1\u00a2\n\u0017\u0000\u0000\u00a2\u00a3\u0005\u0010"+
		"\u0000\u0000\u00a3\u00af\u0003\b\u0004\u0018\u00a4\u00a5\n\u0016\u0000"+
		"\u0000\u00a5\u00a6\u0005\u0011\u0000\u0000\u00a6\u00af\u0003\b\u0004\u0017"+
		"\u00a7\u00a8\n\u0015\u0000\u0000\u00a8\u00a9\u0005\u0012\u0000\u0000\u00a9"+
		"\u00af\u0003\b\u0004\u0016\u00aa\u00ab\n\'\u0000\u0000\u00ab\u00ac\u0005"+
		"7\u0000\u0000\u00ac\u00ad\u0005H\u0000\u0000\u00ad\u00af\u0003\n\u0005"+
		"\u0000\u00aew\u0001\u0000\u0000\u0000\u00aez\u0001\u0000\u0000\u0000\u00ae"+
		"}\u0001\u0000\u0000\u0000\u00ae\u0080\u0001\u0000\u0000\u0000\u00ae\u0083"+
		"\u0001\u0000\u0000\u0000\u00ae\u0086\u0001\u0000\u0000\u0000\u00ae\u0089"+
		"\u0001\u0000\u0000\u0000\u00ae\u008c\u0001\u0000\u0000\u0000\u00ae\u008f"+
		"\u0001\u0000\u0000\u0000\u00ae\u0092\u0001\u0000\u0000\u0000\u00ae\u0095"+
		"\u0001\u0000\u0000\u0000\u00ae\u0098\u0001\u0000\u0000\u0000\u00ae\u009b"+
		"\u0001\u0000\u0000\u0000\u00ae\u009e\u0001\u0000\u0000\u0000\u00ae\u00a1"+
		"\u0001\u0000\u0000\u0000\u00ae\u00a4\u0001\u0000\u0000\u0000\u00ae\u00a7"+
		"\u0001\u0000\u0000\u0000\u00ae\u00aa\u0001\u0000\u0000\u0000\u00af\u00b2"+
		"\u0001\u0000\u0000\u0000\u00b0\u00ae\u0001\u0000\u0000\u0000\u00b0\u00b1"+
		"\u0001\u0000\u0000\u0000\u00b1\t\u0001\u0000\u0000\u0000\u00b2\u00b0\u0001"+
		"\u0000\u0000\u0000\u00b3\u00bc\u0005\r\u0000\u0000\u00b4\u00b9\u0003\b"+
		"\u0004\u0000\u00b5\u00b6\u0005\u0001\u0000\u0000\u00b6\u00b8\u0003\b\u0004"+
		"\u0000\u00b7\u00b5\u0001\u0000\u0000\u0000\u00b8\u00bb\u0001\u0000\u0000"+
		"\u0000\u00b9\u00b7\u0001\u0000\u0000\u0000\u00b9\u00ba\u0001\u0000\u0000"+
		"\u0000\u00ba\u00bd\u0001\u0000\u0000\u0000\u00bb\u00b9\u0001\u0000\u0000"+
		"\u0000\u00bc\u00b4\u0001\u0000\u0000\u0000\u00bc\u00bd\u0001\u0000\u0000"+
		"\u0000\u00bd\u00be\u0001\u0000\u0000\u0000\u00be\u00bf\u0005\u000e\u0000"+
		"\u0000\u00bf\u000b\u0001\u0000\u0000\u0000\u00c0\u00c1\u0005\u001e\u0000"+
		"\u0000\u00c1\u00c2\u0003\b\u0004\u0000\u00c2\u00c3\u0005\"\u0000\u0000"+
		"\u00c3\u00c4\u0005K\u0000\u0000\u00c4\u00c5\u0003\u0006\u0003\u0000\u00c5"+
		"\u00c9\u0005K\u0000\u0000\u00c6\u00c8\u0003\u000e\u0007\u0000\u00c7\u00c6"+
		"\u0001\u0000\u0000\u0000\u00c8\u00cb\u0001\u0000\u0000\u0000\u00c9\u00c7"+
		"\u0001\u0000\u0000\u0000\u00c9\u00ca\u0001\u0000\u0000\u0000\u00ca\u00cd"+
		"\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001\u0000\u0000\u0000\u00cc\u00ce"+
		"\u0003\u0010\b\u0000\u00cd\u00cc\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001"+
		"\u0000\u0000\u0000\u00ce\u00cf\u0001\u0000\u0000\u0000\u00cf\u00d0\u0005"+
		"!\u0000\u0000\u00d0\r\u0001\u0000\u0000\u0000\u00d1\u00d2\u0005\u001f"+
		"\u0000\u0000\u00d2\u00d3\u0003\b\u0004\u0000\u00d3\u00d4\u0005\"\u0000"+
		"\u0000\u00d4\u00d6\u0005K\u0000\u0000\u00d5\u00d7\u0003\u0006\u0003\u0000"+
		"\u00d6\u00d5\u0001\u0000\u0000\u0000\u00d6\u00d7\u0001\u0000\u0000\u0000"+
		"\u00d7\u00d8\u0001\u0000\u0000\u0000\u00d8\u00d9\u0005K\u0000\u0000\u00d9"+
		"\u000f\u0001\u0000\u0000\u0000\u00da\u00db\u0005 \u0000\u0000\u00db\u00dd"+
		"\u0005K\u0000\u0000\u00dc\u00de\u0003\u0006\u0003\u0000\u00dd\u00dc\u0001"+
		"\u0000\u0000\u0000\u00dd\u00de\u0001\u0000\u0000\u0000\u00de\u00df\u0001"+
		"\u0000\u0000\u0000\u00df\u00e0\u0005K\u0000\u0000\u00e0\u0011\u0001\u0000"+
		"\u0000\u0000\u00e1\u00e2\u0005#\u0000\u0000\u00e2\u00e3\u0005H\u0000\u0000"+
		"\u00e3\u00e4\u0005\u001c\u0000\u0000\u00e4\u00e5\u0003\b\u0004\u0000\u00e5"+
		"\u00e6\u0007\u0001\u0000\u0000\u00e6\u00e9\u0003\b\u0004\u0000\u00e7\u00e8"+
		"\u0005\'\u0000\u0000\u00e8\u00ea\u0003\b\u0004\u0000\u00e9\u00e7\u0001"+
		"\u0000\u0000\u0000\u00e9\u00ea\u0001\u0000\u0000\u0000\u00ea\u00eb\u0001"+
		"\u0000\u0000\u0000\u00eb\u00ed\u0005K\u0000\u0000\u00ec\u00ee\u0003\u0006"+
		"\u0003\u0000\u00ed\u00ec\u0001\u0000\u0000\u0000\u00ed\u00ee\u0001\u0000"+
		"\u0000\u0000\u00ee\u00ef\u0001\u0000\u0000\u0000\u00ef\u00f0\u0005K\u0000"+
		"\u0000\u00f0\u00f1\u0005&\u0000\u0000\u00f1\u0013\u0001\u0000\u0000\u0000"+
		"\u00f2\u00f3\u0005C\u0000\u0000\u00f3\u00f4\u0005H\u0000\u0000\u00f4\u00f5"+
		"\u0005\u0007\u0000\u0000\u00f5\u00f6\u00036\u001b\u0000\u00f6\u00f7\u0005"+
		"D\u0000\u0000\u00f7\u00f8\u0003\b\u0004\u0000\u00f8\u00fa\u0005K\u0000"+
		"\u0000\u00f9\u00fb\u0003\u0006\u0003\u0000\u00fa\u00f9\u0001\u0000\u0000"+
		"\u0000\u00fa\u00fb\u0001\u0000\u0000\u0000\u00fb\u00fc\u0001\u0000\u0000"+
		"\u0000\u00fc\u00fd\u0005K\u0000\u0000\u00fd\u00fe\u0005E\u0000\u0000\u00fe"+
		"\u0015\u0001\u0000\u0000\u0000\u00ff\u0100\u0005(\u0000\u0000\u0100\u0101"+
		"\u0003\b\u0004\u0000\u0101\u0103\u0005K\u0000\u0000\u0102\u0104\u0003"+
		"\u0006\u0003\u0000\u0103\u0102\u0001\u0000\u0000\u0000\u0103\u0104\u0001"+
		"\u0000\u0000\u0000\u0104\u0105\u0001\u0000\u0000\u0000\u0105\u0106\u0005"+
		"K\u0000\u0000\u0106\u0107\u0005)\u0000\u0000\u0107\u0017\u0001\u0000\u0000"+
		"\u0000\u0108\u0109\u0005*\u0000\u0000\u0109\u010b\u0005K\u0000\u0000\u010a"+
		"\u010c\u0003\u0006\u0003\u0000\u010b\u010a\u0001\u0000\u0000\u0000\u010b"+
		"\u010c\u0001\u0000\u0000\u0000\u010c\u010d\u0001\u0000\u0000\u0000\u010d"+
		"\u010e\u0005K\u0000\u0000\u010e\u010f\u0005(\u0000\u0000\u010f\u0110\u0003"+
		"\b\u0004\u0000\u0110\u0111\u0005+\u0000\u0000\u0111\u0019\u0001\u0000"+
		"\u0000\u0000\u0112\u011b\u0005\r\u0000\u0000\u0113\u0118\u0003\u0004\u0002"+
		"\u0000\u0114\u0115\u0005\u0001\u0000\u0000\u0115\u0117\u0003\u0004\u0002"+
		"\u0000\u0116\u0114\u0001\u0000\u0000\u0000\u0117\u011a\u0001\u0000\u0000"+
		"\u0000\u0118\u0116\u0001\u0000\u0000\u0000\u0118\u0119\u0001\u0000\u0000"+
		"\u0000\u0119\u011c\u0001\u0000\u0000\u0000\u011a\u0118\u0001\u0000\u0000"+
		"\u0000\u011b\u0113\u0001\u0000\u0000\u0000\u011b\u011c\u0001\u0000\u0000"+
		"\u0000\u011c\u011d\u0001\u0000\u0000\u0000\u011d\u011e\u0005\u000e\u0000"+
		"\u0000\u011e\u001b\u0001\u0000\u0000\u0000\u011f\u0120\u0005.\u0000\u0000"+
		"\u0120\u0121\u0005H\u0000\u0000\u0121\u0122\u0003\u001a\r\u0000\u0122"+
		"\u0124\u0005K\u0000\u0000\u0123\u0125\u0003\u0006\u0003\u0000\u0124\u0123"+
		"\u0001\u0000\u0000\u0000\u0124\u0125\u0001\u0000\u0000\u0000\u0125\u0126"+
		"\u0001\u0000\u0000\u0000\u0126\u0127\u0005K\u0000\u0000\u0127\u0128\u0005"+
		"/\u0000\u0000\u0128\u001d\u0001\u0000\u0000\u0000\u0129\u012a\u00050\u0000"+
		"\u0000\u012a\u012b\u0005H\u0000\u0000\u012b\u012c\u0003\u001a\r\u0000"+
		"\u012c\u012e\u0005K\u0000\u0000\u012d\u012f\u0003\u0006\u0003\u0000\u012e"+
		"\u012d\u0001\u0000\u0000\u0000\u012e\u012f\u0001\u0000\u0000\u0000\u012f"+
		"\u0130\u0001\u0000\u0000\u0000\u0130\u0131\u0005K\u0000\u0000\u0131\u0132"+
		"\u00051\u0000\u0000\u0132\u001f\u0001\u0000\u0000\u0000\u0133\u0138\u0005"+
		"H\u0000\u0000\u0134\u0135\u0005\u0001\u0000\u0000\u0135\u0137\u0005H\u0000"+
		"\u0000\u0136\u0134\u0001\u0000\u0000\u0000\u0137\u013a\u0001\u0000\u0000"+
		"\u0000\u0138\u0136\u0001\u0000\u0000\u0000\u0138\u0139\u0001\u0000\u0000"+
		"\u0000\u0139!\u0001\u0000\u0000\u0000\u013a\u0138\u0001\u0000\u0000\u0000"+
		"\u013b\u013c\u00058\u0000\u0000\u013c\u013f\u0005H\u0000\u0000\u013d\u013e"+
		"\u00059\u0000\u0000\u013e\u0140\u0005H\u0000\u0000\u013f\u013d\u0001\u0000"+
		"\u0000\u0000\u013f\u0140\u0001\u0000\u0000\u0000\u0140\u0143\u0001\u0000"+
		"\u0000\u0000\u0141\u0142\u0005:\u0000\u0000\u0142\u0144\u0003 \u0010\u0000"+
		"\u0143\u0141\u0001\u0000\u0000\u0000\u0143\u0144\u0001\u0000\u0000\u0000"+
		"\u0144\u0145\u0001\u0000\u0000\u0000\u0145\u0147\u0005K\u0000\u0000\u0146"+
		"\u0148\u0003.\u0017\u0000\u0147\u0146\u0001\u0000\u0000\u0000\u0147\u0148"+
		"\u0001\u0000\u0000\u0000\u0148\u0149\u0001\u0000\u0000\u0000\u0149\u014a"+
		"\u0005K\u0000\u0000\u014a\u014b\u0005=\u0000\u0000\u014b#\u0001\u0000"+
		"\u0000\u0000\u014c\u014d\u0007\u0002\u0000\u0000\u014d%\u0001\u0000\u0000"+
		"\u0000\u014e\u0150\u0003$\u0012\u0000\u014f\u014e\u0001\u0000\u0000\u0000"+
		"\u014f\u0150\u0001\u0000\u0000\u0000\u0150\u0152\u0001\u0000\u0000\u0000"+
		"\u0151\u0153\u0005<\u0000\u0000\u0152\u0151\u0001\u0000\u0000\u0000\u0152"+
		"\u0153\u0001\u0000\u0000\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154"+
		"\u0155\u0003\u001c\u000e\u0000\u0155\'\u0001\u0000\u0000\u0000\u0156\u0158"+
		"\u0003$\u0012\u0000\u0157\u0156\u0001\u0000\u0000\u0000\u0157\u0158\u0001"+
		"\u0000\u0000\u0000\u0158\u015a\u0001\u0000\u0000\u0000\u0159\u015b\u0005"+
		"<\u0000\u0000\u015a\u0159\u0001\u0000\u0000\u0000\u015a\u015b\u0001\u0000"+
		"\u0000\u0000\u015b\u015c\u0001\u0000\u0000\u0000\u015c\u015d\u0003\u001e"+
		"\u000f\u0000\u015d)\u0001\u0000\u0000\u0000\u015e\u0160\u0003$\u0012\u0000"+
		"\u015f\u015e\u0001\u0000\u0000\u0000\u015f\u0160\u0001\u0000\u0000\u0000"+
		"\u0160\u0162\u0001\u0000\u0000\u0000\u0161\u0163\u0005<\u0000\u0000\u0162"+
		"\u0161\u0001\u0000\u0000\u0000\u0162\u0163\u0001\u0000\u0000\u0000\u0163"+
		"\u0164\u0001\u0000\u0000\u0000\u0164\u0165\u0005H\u0000\u0000\u0165+\u0001"+
		"\u0000\u0000\u0000\u0166\u016a\u0003&\u0013\u0000\u0167\u016a\u0003(\u0014"+
		"\u0000\u0168\u016a\u0003*\u0015\u0000\u0169\u0166\u0001\u0000\u0000\u0000"+
		"\u0169\u0167\u0001\u0000\u0000\u0000\u0169\u0168\u0001\u0000\u0000\u0000"+
		"\u016a-\u0001\u0000\u0000\u0000\u016b\u016e\u0003,\u0016\u0000\u016c\u016d"+
		"\u0005K\u0000\u0000\u016d\u016f\u0003.\u0017\u0000\u016e\u016c\u0001\u0000"+
		"\u0000\u0000\u016e\u016f\u0001\u0000\u0000\u0000\u016f/\u0001\u0000\u0000"+
		"\u0000\u0170\u0179\u0005\u0002\u0000\u0000\u0171\u0176\u0003\b\u0004\u0000"+
		"\u0172\u0173\u0005K\u0000\u0000\u0173\u0175\u0003\b\u0004\u0000\u0174"+
		"\u0172\u0001\u0000\u0000\u0000\u0175\u0178\u0001\u0000\u0000\u0000\u0176"+
		"\u0174\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000\u0177"+
		"\u017a\u0001\u0000\u0000\u0000\u0178\u0176\u0001\u0000\u0000\u0000\u0179"+
		"\u0171\u0001\u0000\u0000\u0000\u0179\u017a\u0001\u0000\u0000\u0000\u017a"+
		"\u017b\u0001\u0000\u0000\u0000\u017b\u017c\u0005\u0003\u0000\u0000\u017c"+
		"1\u0001\u0000\u0000\u0000\u017d\u018a\u0005\u0004\u0000\u0000\u017e\u017f"+
		"\u0005G\u0000\u0000\u017f\u0180\u0005L\u0000\u0000\u0180\u0187\u0003\b"+
		"\u0004\u0000\u0181\u0182\u0005K\u0000\u0000\u0182\u0183\u0005G\u0000\u0000"+
		"\u0183\u0184\u0005L\u0000\u0000\u0184\u0186\u0003\b\u0004\u0000\u0185"+
		"\u0181\u0001\u0000\u0000\u0000\u0186\u0189\u0001\u0000\u0000\u0000\u0187"+
		"\u0185\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000\u0000\u0000\u0188"+
		"\u018b\u0001\u0000\u0000\u0000\u0189\u0187\u0001\u0000\u0000\u0000\u018a"+
		"\u017e\u0001\u0000\u0000\u0000\u018a\u018b\u0001\u0000\u0000\u0000\u018b"+
		"\u018c\u0001\u0000\u0000\u0000\u018c\u018d\u0005\u0005\u0000\u0000\u018d"+
		"3\u0001\u0000\u0000\u0000\u018e\u0190\u0005F\u0000\u0000\u018f\u018e\u0001"+
		"\u0000\u0000\u0000\u0190\u0193\u0001\u0000\u0000\u0000\u0191\u018f\u0001"+
		"\u0000\u0000\u0000\u0191\u0192\u0001\u0000\u0000\u0000\u01925\u0001\u0000"+
		"\u0000\u0000\u0193\u0191\u0001\u0000\u0000\u0000\u0194\u0195\u0005H\u0000"+
		"\u0000\u0195\u0196\u00034\u001a\u0000\u01967\u0001\u0000\u0000\u0000)"+
		"@GLdhlu\u00ae\u00b0\u00b9\u00bc\u00c9\u00cd\u00d6\u00dd\u00e9\u00ed\u00fa"+
		"\u0103\u010b\u0118\u011b\u0124\u012e\u0138\u013f\u0143\u0147\u014f\u0152"+
		"\u0157\u015a\u015f\u0162\u0169\u016e\u0176\u0179\u0187\u018a\u0191";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}